const {BrowserWindow, app, protocol, net, ipcMain} = require('electron')
const path = require('path')
const fs = require('fs')
const FormData = require('form-data');
const axios = require('axios');
const archiver = require('archiver');
const {exec} = require('child_process');


const createWindow = () => {
    const mainWindow = new BrowserWindow({
        width: 1200, height: 760, minWidth: 1200,   // 设置最小宽度
        minHeight: 760,  // 设置最小高度
        alwaysOnTop: true,  // 窗口置顶
        frame: false, // 隐藏标题栏
        transparent: true, // 透明度
        x: 1500, y: 100, webPreferences: {
            preload: path.resolve(__dirname, 'preload.js'), // nodeIntegration: true, // 允许使用node功能
        }
    })
    mainWindow.loadURL('http://localhost:5173/')
    mainWindow.webContents.openDevTools()
    // mainWindow.loadFile(path.resolve(__dirname, 'index.html'))

    // --------------------控制软件顶部按钮-------------------------
    ipcMain.on('minimize', () => {
        // 最小化
        mainWindow.minimize();
    });

    ipcMain.on('maximize', () => {
        // 最大化
        if (mainWindow.isMaximized()) {
            mainWindow.unmaximize();
        } else {
            mainWindow.maximize();
        }
    });

    ipcMain.on('close', () => {
        // 关闭
        mainWindow.close();
    });
}

app.whenReady().then(() => {
    createWindow();
});

// 监听软件关闭
app.on("window-all-closed", () => {
    if (process.platform !== 'darwin') app.quit()
})

//
app.on('activate', () => {
    if (BrowserWindow.getAllWindows().length === 0) {
        createWindow();
    }
})


ipcMain.handle('get_image_base64', (event, imagePath) => {
    // 读取图片并转为base64
    if (fs.existsSync(imagePath)) {
        let img = fs.readFileSync(imagePath).toString('base64');
        return "data:image/jpeg;base64," + img;
    }
    return '不存在'
});

ipcMain.handle('change_robot_status', (event, args) => {
    const isRunning = args['isRunning']
    const token = args['token']
    console.log(token, isRunning)
    const exePath = `F:\\.desktop\\code\\matrix-client-electron\\autorebot\\main.exe -jwt "JWT ${token}" -pwd "123456"`
    if (!isRunning) {
        console.log("停止机器人")
        // 执行停止操作
        exec(`taskkill /F /IM main.exe`);
        // 返回 false 表示未运行
        event.returnValue = false;
    } else {
        console.log("启动机器人")
        // 执行其他操作
        exec(exePath, (error, stdout, stderr) => {
            if (error) {
                console.error(`执行命令时出错：${error.message}`);
            }
        })
        // 允许启动 exePath
        // 返回 true 表示运行
        event.returnValue = true;
    }
});

const get_tenant_access_token = async (app_id = "cli_a57bdd72d9f3100b", app_secret = "RONC3ZfrMmJuBabbFN7OuhU1cVoe2Y1f") => {
    // 定义请求参数
    const url = 'https://open.feishu.cn/open-apis/auth/v3/tenant_access_token/internal';
    const data = {
        app_id: app_id, app_secret: app_secret
    };
    const headers = {
        'Content-Type': 'application/json; charset=utf-8'
    };

    // 发送POST请求
    return axios.post(url, data, {headers: headers})
        .then(response => {
            // 请求成功，处理响应数据
            // console.log('Response:', response.data);
            return response.data
        })
        .catch(error => {
            // 请求失败，处理错误
            // console.error('Error:', error.response ? error.response.data : error.message);
            return error.response ? error.response.data : error.message
        });
}

// 上传文件
async function uploadFile(filePath, tenant_access_token, file_name) {
    const fileStream = fs.createReadStream(filePath);
    const url = 'https://open.feishu.cn/open-apis/drive/v1/files/upload_all';

    // 创建多部分表单数据
    const formData = new FormData();
    formData.append('file_name', file_name + ".zip");
    formData.append('parent_type', 'explorer');
    formData.append('parent_node', 'Aarlf0hTult4Lnd2BDjcQPHunMf');
    formData.append('size', fs.statSync(filePath).size);
    formData.append('file', fileStream);

    // 发送POST请求
    return axios.post(url, formData, {
        headers: {
            ...formData.getHeaders(),
            'Authorization': 'Bearer ' + tenant_access_token, // 替换为实际的token
        }
    }).then(response => {
        return response.data
    }).catch(error => {
        console.error('Error:', error.response ? error.response.data : error.message);
    })
}


// 压缩文件夹
const compressDir = async (temp__item_name, temp_dir, temp__item_dir) => {
    // 将刚才生成的临时文件夹(temp__item_dir)压缩为zip
    // 创建压缩文件
    const zip_name = temp__item_name + '.zip';
    const zip_path = path.resolve(temp_dir, zip_name);
    const output = fs.createWriteStream(zip_path);
    const archive = archiver('zip', {
        zlib: {level: 9} // 设置压缩级别
    });
    await output.on('close', function () {
        console.log(archive.pointer() + ' total bytes');
        console.log('archiver has been finalized and the output file descriptor has closed.');
    });
    await archive.on('error', function (err) {
        throw err;
    });
    // 将文件夹添加到压缩包中
    await archive.directory(temp__item_dir, false);

    // 完成压缩并关闭流
    await archive.pipe(output);
    await archive.finalize();

    // 返回压缩文件路径
    return zip_path
}

ipcMain.handle('send_to_feishu', async (event, req_data) => {
    var temp_dir = path.resolve(__dirname, 'temp_distribute');

    // 清空文件夹内容的函数
    function clearDirectory(directory) {
        fs.readdirSync(directory).forEach(file => {
            const fullPath = path.join(directory, file);
            if (fs.lstatSync(fullPath).isDirectory()) {
                // 如果是一个目录，则递归清空
                clearDirectory(fullPath);
                fs.rmdirSync(fullPath);
            } else {
                // 如果是一个文件，则直接删除
                fs.unlinkSync(fullPath);
            }
        });
    }

    // 检查文件夹是否存在
    if (fs.existsSync(temp_dir)) {
        // 如果存在，则清空文件夹
        clearDirectory(temp_dir);
    } else {
        // 如果不存在，则创建文件夹
        fs.mkdirSync(temp_dir);
    }

    // 校验媒体资源是否存在
    for (let item of req_data) {
        let media_str = item['content']['媒体']
        if (media_str) {
            var media_list = media_str.replace(/^;|;$/g, '').split(";")
            // 校验媒体资源是否存在
            for (let media of media_list) {
                if (media && !fs.existsSync(media)) {
                    return {
                        code: 1, msg: media + "媒体资源不存在"
                    }
                }
            }
        }
        let cover = item['content']['封面']
        if (cover) {
            // 校验媒体资源是否存在
            if (cover && !fs.existsSync(cover)) {
                return {
                    code: 1, msg: cover + "媒体资源不存在"
                }
            }
        }


        // 在整体临时文件夹下使用uuid创建子文件夹
        let temp__item_name = require('uuid').v4()
        let temp__item_dir = path.resolve(temp_dir, temp__item_name)
        // 如果不存在则创建
        if (!fs.existsSync(temp__item_dir)) {
            fs.mkdirSync(temp__item_dir)
        }

        // 将媒体资源复制到临时文件夹。并将每个文件用uuid重命名，在替换列表中的元素。需要保留后缀名
        if (media_str) {
            for (let media of media_list) {
                if (media) {
                    let ext = path.extname(media)
                    let new_name = path.resolve(temp__item_dir, require('uuid').v4() + ext)
                    fs.copyFileSync(media, new_name)
                    // 获取文件名
                    let filename = path.basename(new_name)
                    // 替换原媒体资源
                    media_str = media_str.replace(media, filename)
                }
            }
            item['content']['媒体'] = media_str
        }

        // 将封面资源复制到临时文件夹 并将文件名替换为uuid。需要保留后缀名
        if (cover) {
            let ext = path.extname(cover)
            let new_name = path.resolve(temp__item_dir, require('uuid').v4() + ext)
            fs.copyFileSync(cover, new_name)
            // 获取文件名
            let filename = path.basename(new_name)
            item['content']['封面'] = filename
        }
        item['content']['temp_dir'] = temp__item_name

        // 压缩文件夹
        let zip_path = await compressDir(temp__item_name, temp_dir, temp__item_dir)
        item['content']['zip_path'] = zip_path
        // 删除临时文件夹
        await fs.rmdirSync(temp__item_dir, {recursive: true})


    }
    // console.log(req_data)


    // 获取访问令牌
    var tenant_access_token_response = await get_tenant_access_token()
    if (tenant_access_token_response.code !== 0) {
        return {
            code: 1,
            msg: "获取访问令牌失败"
        }
    }

    // 上传文件
    for (let item of req_data) {
        let temp_dir = item['content']['zip_path']
        let temp_name = item['content']['temp_dir']
        let task_name = item['task_name']
        let file_response = await uploadFile(temp_dir, tenant_access_token_response.tenant_access_token, task_name + temp_name)
        item['content']['file_token'] = file_response.data.file_token
        item['content']['category'] = "图文"  // 图文类型
    }
    // console.log(req_data)
    return {
        code: 0, msg: "上传成功", data: req_data
    }

})




